// 云对象教程: https://uniapp.dcloud.net.cn/uniCloud/cloud-obj
// jsdoc语法提示教程：https://ask.dcloud.net.cn/docs/#//ask.dcloud.net.cn/article/129
const db = uniCloud.database();
const rolesCollection = db.collection('roles');
const { verifyToken } = require('aiutils');

/**
 * 确保角色有所有必要的字段
 * @param {object} role 角色信息
 * @param {string} userId 用户ID
 * @returns {object} 完整的角色信息
 */
function ensureRoleFields(role, userId) {
	// 基本字段
	const defaultFields = {
		name: role.name || '',
		description: role.description || '',
		avatar: role.avatar || '/static/avatars/default.png',
		prompt: role.prompt || '',
		greeting: role.greeting || '',
		isCustom: role.isCustom !== undefined ? role.isCustom : true,
		isDefault: role.isDefault !== undefined ? role.isDefault : false,
		isAdult: role.isAdult !== undefined ? role.isAdult : false,
		model: role.model || '',
		userId: userId, // 添加用户ID
		createTime: role.createTime || Date.now(),
		updateTime: Date.now()
	};
	
	// 如果是高级角色，添加高级角色特有字段
	if (role.isAdult) {
		return {
			...defaultFields,
			age: role.age || '',
			gender: role.gender || '',
			occupation: role.occupation || '',
			hobbies: role.hobbies || '',
			appearance: role.appearance || '',
			personality: role.personality || '',
			background: role.background || '',
			scenario: role.scenario || '',
			interactionPriorities: role.interactionPriorities || '',
			attentionPoints: role.attentionPoints || ''
		};
	}
	
	return defaultFields;
}

/**
 * 验证用户token并获取用户ID
 * @param {string} token - 用户token
 * @returns {string|null} 用户ID，如果token无效则返回null
 */
async function validateTokenAndGetUserId(token) {
	// 如果没有token，返回null
	if (!token) {
		return null;
	}
	
	try {
		// 处理Bearer token格式
		const actualToken = token.startsWith('Bearer ') ? token.slice(7) : token;
		
		// 验证token
		const verifyResult = verifyToken(actualToken);
		
		// 如果验证失败，返回null
		if (!verifyResult.valid) {
			return null;
		}
		
		// 从token中获取用户ID
		const userId = verifyResult.payload.userId;
		
		// 查询用户信息
		const userCollection = db.collection('users');
		const userResult = await userCollection.doc(userId).get();
		
		if (userResult.data.length === 0) {
			return null;
		}
		
		// 返回用户ID
		return userResult.data[0]._id;
	} catch (error) {
		// 出现任何错误，返回null
		return null;
	}
}

module.exports = {
	/**
	 * 获取所有角色（包括系统默认角色和用户自己的角色）
	 * @param {string} token - 用户token
	 * @returns {object} 包含所有角色的数组
	 */
	async getAllRoles(token) {
		try {
			// 验证token并获取用户ID
			const userId = await validateTokenAndGetUserId(token);
			
			// 查询条件
			let query = {};
			
			// 如果用户已登录，返回系统默认角色和用户自己的角色
			// 如果用户未登录，只返回系统默认角色
			if (userId) {
				query = {
					$or: [
						{ isDefault: true },
						{ userId: userId }
					]
				};
			} else {
				query = { isDefault: true };
			}
			
			// 执行查询
			const { data: roles } = await rolesCollection.where(query).get();
			
			return {
				errCode: 0,
				errMsg: '获取角色列表成功',
				data: roles
			};
		} catch (error) {
			return {
				errCode: 'GET_ROLES_FAILED',
				errMsg: '获取角色列表失败：' + error.message,
				data: [] // 发生错误时返回空数组
			};
		}
	},
	
	/**
	 * 获取高级角色（包括系统默认高级角色和用户自己的高级角色）
	 * @param {string} token - 用户token
	 * @returns {object} 包含高级角色的数组
	 */
	async getAdultRoles(token) {
		try {
			// 验证token并获取用户ID
			const userId = await validateTokenAndGetUserId(token);
			
			// 查询条件
			let query = { isAdult: true };
			
			// 如果用户已登录，返回系统默认角色和用户自己的角色
			// 如果用户未登录，只返回系统默认角色
			if (userId) {
				query.$or = [
					{ isDefault: true },
					{ userId: userId }
				];
			} else {
				query.isDefault = true;
			}
			
			// 执行查询
			const { data: roles } = await rolesCollection.where(query).get();
			
			return {
				errCode: 0,
				errMsg: '获取高级角色列表成功',
				data: roles
			};
		} catch (error) {
			return {
				errCode: 'GET_ADULT_ROLES_FAILED',
				errMsg: '获取高级角色列表失败：' + error.message,
				data: [] // 发生错误时返回空数组
			};
		}
	},
	
	/**
	 * 获取非高级角色（包括系统默认非高级角色和用户自己的非高级角色）
	 * @param {string} token - 用户token
	 * @returns {object} 包含非高级角色的数组
	 */
	async getNonAdultRoles(token) {
		try {
			// 验证token并获取用户ID
			const userId = await validateTokenAndGetUserId(token);
			
			// 查询条件
			let query = { isAdult: false };
			
			// 如果用户已登录，返回系统默认角色和用户自己的角色
			// 如果用户未登录，只返回系统默认角色
			if (userId) {
				query.$or = [
					{ isDefault: true },
					{ userId: userId }
				];
			} else {
				query.isDefault = true;
			}
			
			// 执行查询
			const { data: roles } = await rolesCollection.where(query).get();
			
			return {
				errCode: 0,
				errMsg: '获取普通角色列表成功',
				data: roles
			};
		} catch (error) {
			return {
				errCode: 'GET_NON_ADULT_ROLES_FAILED',
				errMsg: '获取普通角色列表失败：' + error.message,
				data: [] // 发生错误时返回空数组
			};
		}
	},
	
	/**
	 * 根据ID获取角色（只能获取系统默认角色或用户自己的角色）
	 * @param {string} token - 用户token
	 * @param {string} id - 角色ID
	 * @returns {object} 角色信息
	 */
	async getRoleById(token, id) {
		// 参数校验
		if (!id) {
			return {
				errCode: 'PARAM_IS_NULL',
				errMsg: '角色ID不能为空',
				data: null
			};
		}
		
		try {
			// 验证token并获取用户ID
			const userId = await validateTokenAndGetUserId(token);
			
			// 查询角色
			const { data } = await rolesCollection.doc(id).get();
			
			if (data && data.length > 0) {
				const role = data[0];
				
				// 检查权限：
				// 1. 如果是系统默认角色，任何人都可以访问
				// 2. 如果是用户自己的角色，需要用户已登录
				if (role.isDefault || (userId && role.userId === userId)) {
					return {
						errCode: 0,
						errMsg: '获取角色成功',
						data: role
					};
				} else {
					// 无权访问，返回null
					return {
						errCode: 'PERMISSION_DENIED',
						errMsg: '无权访问该角色',
						data: null
					};
				}
			} else {
				return {
					errCode: 'ROLE_NOT_FOUND',
					errMsg: '未找到该角色',
					data: null
				};
			}
		} catch (error) {
			return {
				errCode: 'GET_ROLE_FAILED',
				errMsg: '获取角色失败：' + error.message,
				data: null
			};
		}
	},
	
	/**
	 * 添加角色（自动关联到当前用户）
	 * @param {string} token - 用户token
	 * @param {object} role - 角色信息
	 * @returns {object} 添加结果
	 */
	async addRole(token, role) {
		// 参数校验
		if (!role) {
			return {
				errCode: 'PARAM_IS_NULL',
				errMsg: '角色信息不能为空'
			};
		}
		
		try {
			// 验证token并获取用户ID
			const userId = await validateTokenAndGetUserId(token);
			
			// 如果用户未登录，不允许添加角色
			if (!userId) {
				return {
					errCode: 'NOT_LOGGED_IN',
					errMsg: '请先登录后再添加角色'
				};
			}
			
			// 确保角色有必要的字段，并关联到当前用户
			const completeRole = ensureRoleFields(role, userId);
			
			// 普通用户不能创建系统默认角色
			if (completeRole.isDefault) {
				completeRole.isDefault = false;
			}
			
			const result = await rolesCollection.add(completeRole);
			return {
				errCode: 0,
				errMsg: '添加角色成功',
				data: {
					id: result.id,
					...completeRole
				}
			};
		} catch (error) {
			return {
				errCode: 'ADD_ROLE_FAILED',
				errMsg: '添加角色失败：' + error.message
			};
		}
	},
	
	/**
	 * 更新角色（只能更新用户自己的角色）
	 * @param {string} token - 用户token
	 * @param {object} role - 角色信息
	 * @returns {object} 更新结果
	 */
	async updateRole(token, role) {
		// 参数校验
		if (!role || !role._id) {
			return {
				errCode: 'PARAM_IS_NULL',
				errMsg: '角色信息或ID不能为空'
			};
		}
		
		try {
			// 验证token并获取用户ID
			const userId = await validateTokenAndGetUserId(token);
			
			// 如果用户未登录，不允许更新角色
			if (!userId) {
				return {
					errCode: 'NOT_LOGGED_IN',
					errMsg: '请先登录后再更新角色'
				};
			}
			
			// 先查询角色，检查权限
			const { data } = await rolesCollection.doc(role._id).get();
			
			if (!data || data.length === 0) {
				return {
					errCode: 'ROLE_NOT_FOUND',
					errMsg: '未找到该角色'
				};
			}
			
			const existingRole = data[0];
			
			// 检查权限：只能更新用户自己的角色，不能更新系统默认角色
			if (existingRole.isDefault) {
				return {
					errCode: 'PERMISSION_DENIED',
					errMsg: '不能修改系统默认角色'
				};
			}
			
			if (existingRole.userId !== userId) {
				return {
					errCode: 'PERMISSION_DENIED',
					errMsg: '无权修改该角色'
				};
			}
			
			// 确保角色有必要的字段，并保持用户ID不变
			const completeRole = ensureRoleFields(role, existingRole.userId);
			const id = role._id;
			delete completeRole._id; // 移除_id字段，避免更新时出错
			
			// 不允许修改为系统默认角色
			completeRole.isDefault = false;
			
			await rolesCollection.doc(id).update(completeRole);
			return {
				errCode: 0,
				errMsg: '更新角色成功',
				data: {
					_id: id,
					...completeRole
				}
			};
		} catch (error) {
			return {
				errCode: 'UPDATE_ROLE_FAILED',
				errMsg: '更新角色失败：' + error.message
			};
		}
	},
	
	/**
	 * 删除角色（只能删除用户自己的角色）
	 * @param {string} token - 用户token
	 * @param {string} id - 角色ID
	 * @returns {object} 删除结果
	 */
	async deleteRole(token, id) {
		// 参数校验
		if (!id) {
			return {
				errCode: 'PARAM_IS_NULL',
				errMsg: '角色ID不能为空'
			};
		}
		
		try {
			// 验证token并获取用户ID
			const userId = await validateTokenAndGetUserId(token);
			
			// 如果用户未登录，不允许删除角色
			if (!userId) {
				return {
					errCode: 'NOT_LOGGED_IN',
					errMsg: '请先登录后再删除角色'
				};
			}
			
			// 先查询角色，检查权限
			const { data } = await rolesCollection.doc(id).get();
			
			if (!data || data.length === 0) {
				return {
					errCode: 'ROLE_NOT_FOUND',
					errMsg: '未找到该角色'
				};
			}
			
			const role = data[0];
			
			// 检查权限：只能删除用户自己的角色，不能删除系统默认角色
			if (role.isDefault) {
				return {
					errCode: 'PERMISSION_DENIED',
					errMsg: '不能删除系统默认角色'
				};
			}
			
			if (role.userId !== userId) {
				return {
					errCode: 'PERMISSION_DENIED',
					errMsg: '无权删除该角色'
				};
			}
			
			await rolesCollection.doc(id).remove();
			return {
				errCode: 0,
				errMsg: '删除角色成功'
			};
		} catch (error) {
			return {
				errCode: 'DELETE_ROLE_FAILED',
				errMsg: '删除角色失败：' + error.message
			};
		}
	}
}
